﻿import Toolbar from './Toolbar.vue'
import ContextMenu from './Context-menu.vue'
import Editor from './Editor.vue'
import './custom_item.js'
export default {
  components: {
    Toolbar,
    ContextMenu
  },
  name: 'workflow_define',
  extends: Editor,
  data () {
    return {
      // 判断状态的(新增--有一个未发布就不可再次新增、保存、编辑、删除)
      hadUnpublishedVersion: false,
      currentVersionStatus: 1,
      // 当前工作流的版本列表
      currentWorkflowVersionList: [],
      // 当前选中的版本id
      selectWFID: '',
      // 当前选中的版本信息
      selectVersionInfo: {},
      // 是否是新增了一个版本
      isAddVersion: false,
      // 事件名称
      EventNamelist: [],
      // 边的行为集合---根据前一节点的行为获取
      firstNodes: [],
      // 当前版本信息名称
      currentName: '',
      Base: '',
      // 当前选中的节点
      currentNode: '',
      // 节点的相关信息
      NodeID: '',
      Title: '',
      Type: '',
      // 中间节点的长度和高度
      tempInputingSize_width: '',
      tempInputingSize_heigth: '',
      // 动态属性
      attr_tableData: [],
      // 节点行为
      action_tableData: [],
      // 用户规则
      user_tableData: [],
      // 事件规则
      events_tableData: [],
      // 边的行为编码
      ActionCode: '',
      // 边的扩展属性
      ExtendData: '',
      loading: false,
      // 在保存发布新建后需要记住是哪一个流程版本
      rememberWFID: ''
    }
  },
  created () {
    this.init()
  },
  methods: {
    // 初始化页面加载指定Code参数的数据
    init () {
      this.hadUnpublishedVersion = false
      this.currentVersionStatus = 1
      this.selectVersionInfo = {}
      this.selectWFID = ''
      this.getEvents()
      this.initWorkflowPage(this.$route.query.Code)
    },
    // 页面初始化加载所有事件
    getEvents () {
      this.loading = true
      this.$basicWFGet('/events4dform/alllist').then(data => {
        this.loading = false
        if (data.data.result.code === 'success') {
          this.EventNamelist = data.data.result.data
        }
      }).catch(error => {
        console.log(error)
      })
    },
    // 页面初始化时请求数据加载
    initWorkflowPage (pathCode) {
      this.loading = true
      this.$basicWFPost('/WorkFlowMgr/getworkflow', {
        Code: pathCode
      }).then(data => {
        let dataInfo = data.data.result
        if (dataInfo.code === 'success') {
          // 展示流程名称
          this.currentName = dataInfo.data[0].Base.Title
          // 当前流程的基础信息
          this.Base = dataInfo.data[0].Base
          // 当前选中的版本--如果需要记住版版本，则需要选中该版本
          if (this.rememberWFID) {
            this.selectWFID = this.rememberWFID
          } else {
            // 否者的话就为流程指定的版本
            this.selectWFID = dataInfo.data[0].Base.CurWFID
          }
          // 所有的版本信息
          this.currentWorkflowVersionList = dataInfo.data[0].Masters
          // 该流程有版本信息时
          if (this.currentWorkflowVersionList.length) {
            // 并将版本信息按照版本号由小到大进行排列
            this.currentWorkflowVersionList.sort(this.rank('Version'))
            if (!this.selectWFID) {
              // 如果没有版本，则默认选择版本记录中的第一条
              this.selectWFID = this.currentWorkflowVersionList[0].Master.WFID
            }
            // 判断是否有未发布的版本
            this.currentWorkflowVersionList.forEach(item => {
              if (!item.Master.Status) { // Status为0时,表示未发布,1表示已发布
                this.hadUnpublishedVersion = true
              }
            })
          } else {
            // 该流程没有版本信息时
            this.hadUnpublishedVersion = true
            this.currentVersionStatus = 0
            this.selectVersionInfo = {}
            this.selectWFID = ''
            // this.page.read({})
            // 加载已经画好的流程图
            this.initWorlflowData({})
          }
        } else if (dataInfo.code === 'failed') {
          this.$message({
            message: dataInfo.msg,
            type: 'error'
          })
        }
        this.loading = false
        // 将新增的指示还原
        this.isAddVersion = false
      })
    },
    // 加载已经画好的流程图
    initWorlflowData (data) {
      if (this.page) {
        this.page = null
        this.editor.destroy()
      }
      this.$nextTick(() => {
        this.initEditor()
        this.page.read(data)
      })
    },
    // 版本排序的方法
    rank (propertyName) {
      return function (a, b) {
        let ahead = a.Master[propertyName]
        let next = b.Master[propertyName]
        if (ahead < next) {
          return -1
        } else if (ahead > next) {
          return 1
        } else {
          return 0
        }
      }
    },
    // 获取选中的版本信息
    getSelectVersionInfo (currentSelectedWFID) {
      if (this.currentWorkflowVersionList.length) {
        this.currentWorkflowVersionList.forEach(item => {
          if (currentSelectedWFID === item.Master.WFID) {
            this.initWorlflowData(JSON.parse(item.Master.JsonData))
            this.currentVersionStatus = item.Master.Status
            this.selectVersionInfo = item.Master
          }
        })
      }
    },
    // 新建事件
    addPlus () {
      this.$confirm('确定要以当前版本为基础，新增一个流程版本么', '提示', {
        confirmButtonText: '确定',
        cancelButtonClass: 'el-button--info',
        cancelButtonText: '取消'
      }).then(() => {
        this.isAddVersion = true
        this.saveMethod()
      }).catch(() => { })
    },
    // 删除事件
    delCurrent () {
      this.$confirm('确定要删除该工作流么?', '提示', {
        confirmButtonText: '确定',
        cancelButtonClass: 'el-button--info',
        cancelButtonText: '取消'
      }).then(() => {
        this.loading = true
        this.$basicWFPost('/WorkFlowMgr/DeleteWorkflowMaster', {
          WFID: this.selectWFID
        }).then(data => {
          this.loading = false
          if (data.data.result.code === 'success') {
            this.$message({
              message: data.data.result.msg,
              type: 'success'
            })
            this.rememberWFID = ''
            // 成功删除 初始化页面
            this.init()
          } else {
            this.$message({
              message: data.data.result.msg,
              type: 'error'
            })
          }
        }).catch(error => {
          console.log(error)
        })
      }).catch(() => { })
    },
    // 发布事件
    submitData () {
      // 判断该工作流是否有节点
      let isEmptyObject = this.$isEmptyObject(this.page.save())
      if (!isEmptyObject) {
        this.$confirm('确定要提交该工作流么?', '提示', {
          confirmButtonText: '确定',
          cancelButtonClass: 'el-button--info',
          cancelButtonText: '取消'
        }).then(() => {
          // 提交发布的方法
          this.publicMethod()
        }).catch(() => { })
      } else {
        this.$message({
          message: '请为该工作流添加流程信息',
          type: 'warning'
        })
      }
    },
    // 发布方法
    publicMethod () {
      this.loading = true
      // 根据是该流程是否有历史版本来判断保存的路由---只有第一次的时候才会是新建更新
      let saveRoute = ''
      if (!this.currentWorkflowVersionList.length) {
        // 新增发布时
        saveRoute = 'CreateWorkflowMaster'
      } else {
        // 更新发布时
        saveRoute = 'UpdateWorkflowMaster'
      }
      this.$basicWFPost('/WorkFlowMgr/' + saveRoute, {
        Master: this.getSubmitData(1) // Status 1
      }).then(data => {
        this.loading = false
        if (data.data.result.code === 'success') {
          this.$message({
            message: '发布成功！',
            type: 'success'
          })
          this.rememberWFID = data.data.result.data.Master.WFID
          // 发布成功 初始化页面
          this.init()
        } else if (data.data.result.code === 'failed') {
          this.$message({
            message: '请检查流程是否绘制正确(节点名称不可过长)',
            type: 'error'
          })
        }
      }).catch(error => {
        this.$message({
          message: '请检查流程是否绘制正确(节点名称不可过长)',
          type: 'error'
        })
        this.loading = false
      })
    },
    // 保存的方法
    saveMethod () {
      // 根据是该流程是否有历史版本来判断保存的路由---只有第一次的时候才会是新建更新
      let saveRoute = ''
      if (!this.currentWorkflowVersionList.length) {
        // 新增保存时
        saveRoute = 'CreateWorkflowMaster'
      } else {
        // 更新保存时
        saveRoute = 'UpdateWorkflowMaster'
      }
      // 当为新增时
      if (this.isAddVersion) {
        saveRoute = 'CreateWorkflowMaster'
      }
      this.$basicWFPost('/WorkFlowMgr/' + saveRoute, {
        Master: this.getSubmitData(0) // Status 0
      }).then(data => {
        this.loading = false
        if (data.data.result.code === 'success') {
          if (!this.isAddVersion) {
            this.$message({
              message: '保存成功！',
              type: 'success'
            })
          } else {
            this.$message({
              message: '新建成功！',
              type: 'success'
            })
          }
          if (data.data.result.data.Master.WFID) {
            this.rememberWFID = data.data.result.data.Master.WFID
          }
          this.init()
        } else if (data.data.result.code === 'failed') {
          this.$message({
            message: '请检查流程是否绘制正确(节点名称不可过长)',
            type: 'error'
          })
        }
      }).catch(error => {
        this.$message({
          message: '请检查流程是否绘制正确(节点名称不可过长)',
          type: 'error'
        })
        this.loading = false
      })
    },
    // 保存事件
    getSaveData () {
      let isEmptyObject = this.$isEmptyObject(this.page.save())
      if (!isEmptyObject) {
        this.$confirm('您是否确定要保存该工作流吗?', '提示', {
          confirmButtonText: '确定',
          cancelButtonClass: 'el-button--info',
          cancelButtonText: '取消'
        }).then(() => {
          this.saveMethod()
        }).catch(() => { })
      } else {
        this.$message({
          message: '请为该工作流添加流程信息,才能进行保存！',
          type: 'warning'
        })
      }
    },
    // 获取新增流程时提交的数据
    getSubmitData (status) {
      // 保存时 status为0 ,发布时为1
      let originData = this.page.save()
      let myVersion = 1
      if (!this.$isEmptyObject(this.selectVersionInfo)) {
        myVersion = this.selectVersionInfo.Version
      }
      // 当为新增时，版本号应该是当前所有版本中最大的版本号加1
      if (this.isAddVersion && this.currentWorkflowVersionList.length) {
        myVersion = this.currentWorkflowVersionList[this.currentWorkflowVersionList.length - 1].Master.Version + 1
      }
      let requestData = {
        Master: {
          WFID: this.isAddVersion ? '' : this.selectWFID,
          Code: this.Base.Code,
          Version: myVersion,
          Remark: this.Base.Remark,
          JsonData: JSON.stringify(originData),
          Status: status
        },
        Nodes: [],
        Lines: []
      }
      if (originData.nodes && originData.nodes.length) {
        originData.nodes.forEach(item => {
          let actionsArr = [] // 将actions传值转换成后端的对应key
          for (let k = 0; k < item.action.length; k++) {
            let actionsObj = {
              Code: item.action[k].code,
              Title: item.action[k].title,
              Type: item.action[k].type
            }
            actionsArr.push(actionsObj)
          }
          let UserRulesArr = [] // 将userrules传值转换成后端的对应key
          for (let k = 0; k < item.userrules.length; k++) {
            let UserRulesObj = {
              DepCode: item.userrules[k].depcode,
              TitleCode: item.userrules[k].titlecode,
              Type: item.userrules[k].type
            }
            UserRulesArr.push(UserRulesObj)
          }
          let attributesArr = [] // 将attributes传值转换成后端的对应key
          for (let k = 0; k < item.attributes.length; k++) {
            let attributesObj = {
              Name: item.attributes[k].name,
              Value: item.attributes[k].value
            }
            attributesArr.push(attributesObj)
          }
          let nodeObj = {
            NodeID: item.id,
            WFID: this.selectWFID,
            Title: item.label,
            Type: item.nodetype,
            Actions: actionsArr,
            Attributes: attributesArr,
            UserRules: UserRulesArr,
            Controls: ''
          }
          requestData.Nodes.push(nodeObj)
        })
      }
      if (originData.edges && originData.edges.length) {
        originData.edges.forEach(item => {
          let arr = []
          if (item.events && item.events.length) {
            for (let i = 0; i < item.events.length; i++) {
              let obj = {
                EventName: item.events[i].eventname,
                EventNo: item.events[i].eventno,
                EventType: item.events[i].eventtype
              }
              arr.push(obj)
            }
          }
          let edgesObj = {
            ID: item.id,
            WFID: this.selectWFID,
            ActionCode: item.actioncode,
            ActionTitle: item.label,
            ExtendData: item.extenddata,
            StartNodeID: item.source,
            EndNodeID: item.target,
            Events: arr
          }
          requestData.Lines.push(edgesObj)
        })
      }
      return requestData
    },
    // 改变线的类型
    changeEage (type) {
      this.page.changeAddEdgeModel({
        shape: type,
        label: '',
        actioncode: '',
        extenddata: '',
        events: []
      })
    },
    // 新增摸一个节点的信息
    addData (typeName) {
      if (typeName === 'attr') {
        this.attr_tableData.push({
          name: '',
          value: ''
        })
      } else if (typeName === 'action') {
        this.action_tableData.push({
          code: '',
          title: '',
          type: ''
        })
      } else if (typeName === 'user') {
        this.user_tableData.push({
          depcode: '',
          titlecode: '',
          type: ''
        })
      } else if (typeName === 'AddEvents') {
        this.events_tableData.push({
          eventno: '',
          eventname: '',
          eventtype: ''
        })
      }
    },
    // 删除某一个节点的信息
    deleteData (typeName, index) {
      if (typeName === 'attr') {
        this.attr_tableData.splice(index, 1)
      } else if (typeName === 'action') {
        this.action_tableData.splice(index, 1)
      } else if (typeName === 'user') {
        this.user_tableData.splice(index, 1)
      } else if (typeName === 'AddEvents') {
        this.events_tableData.splice(index, 1)
      }
    },
    // 通过编码找行为名称
    findActionName (val) {
      let returnTitleName = ''
      if (this.firstNodes.length && val) {
        this.firstNodes.map((item) => {
          if (item.code === val) {
            returnTitleName = item.title
          }
        })
      }
      return returnTitleName
    },
    // onchange 事件进行传递title参数
    writeTitle (val, row) {
      if (val) {
        if (val === 'Submit') {
          row.title = '提交'
        } else if (val === 'Save') {
          row.title = '保存'
        } else if (val === 'Delete') {
          row.title = '删除'
        } else if (val === 'Pass') {
          row.title = '通过'
        } else if (val === 'Reject') {
          row.title = '驳回'
        } else if (val === 'SelectReject') {
          row.title = '选择驳回'
        } else if (val === 'Stop') {
          row.title = '终止'
        } else if (val === 'Apply') {
          row.title = '申请'
        } else if (val === 'SubmitPending') {
          row.title = '提交挂起'
        } else if (val === 'ActivePending') {
          row.title = '恢复挂起'
        }
      }
    },
    // 监听事件下拉框第二个(名称) 传值
    watchEvent (val, row) {
      this.EventNamelist.map((item) => {
        if (item.no === val) {
          row.eventname = item.name
          row.eventno = item.no
        }
      })
    }
  },
  watch: {
    // 监听selectWFID的变化
    selectWFID: {
      handler: function (val, oldVal) {
        if (val) {
          this.getSelectVersionInfo(val)
        }
      }
    },
    selectedModel: {
      handler: function (val) {
        this.currentNode = val
        // 属性 val.attributes   //用户规则 val.userrules  //行为 val.action
        if (val) {
          this.currentNode = val
          this.Title = val.label
          this.NodeID = val.id
          // 为节点时
          if (val.type === 'node') {
            this.Type = val.nodetype
            // 将数据存放在表格中
            this.attr_tableData = val.attributes || []
            this.action_tableData = val.action || []
            this.user_tableData = val.userrules || []
          }
          // 为边时
          if (val.shape === 'line' || val.shape === 'flow-polyline-round' || val.shape === 'flow-smooth') {
            // 将数据存放在表格中
            this.events_tableData = val.events || []
            this.page.save().nodes.forEach((item) => {
              if (item.id === val.source) {
                this.firstNodes = item.action.filter((item) => {
                  return item.type === '1'
                })
              }
            })
            this.ActionCode = val.actioncode
            this.ExtendData = val.extenddata
          }
          // 普通节点的长度
          if (val.size) {
            this.tempInputingSize_width = val.size.split('*')[0]
            this.tempInputingSize_heigth = val.size.split('*')[1]
          }
        }
      },
      deep: true
    },
    // 节点名称/边的文字改变时
    Title: {
      handler: function (val) {
        this.updateGraph('label', val)
      },
      deep: true
    },
    // 节点类型改变时
    Type: {
      handler: function (val) {
        this.updateGraph('nodetype', val)
      },
      deep: true
    },
    // 动态属性
    attr_tableData: {
      handler: function (val) {
        this.updateGraph('attributes', val)
      },
      deep: true
    },
    // 节点行为
    action_tableData: {
      handler: function (val) {
        this.updateGraph('action', val)
      },
      deep: true
    },
    // 用户规则
    user_tableData: {
      handler: function (val) {
        this.updateGraph('userrules', val)
      },
      deep: true
    },
    // 事件规则
    events_tableData: {
      handler: function (val) {
        this.updateGraph('events', val)
      },
      deep: true
    },
    // 节点的长度
    tempInputingSize_width: {
      handler: function (val) {
        this.updateGraph('size', val + '*' + this.tempInputingSize_heigth)
      },
      deep: true
    },
    // 行为编码
    ActionCode: {
      handler: function (val) {
        this.updateGraph('label', this.findActionName(val))
        this.updateGraph('actioncode', val)
      },
      deep: true
    },
    // 扩展属性
    ExtendData: {
      handler: function (val) {
        this.updateGraph('extenddata', val)
      },
      deep: true
    }
  }
}
